Node est disponible dans les dépôts officiels des systèmes suivants :

Si votre système d’exploitation ne dispose pas de paquet pour Node, essayez dans l’ordre :

Le paquet officiel nodejs fourni dans les dépôts apt est à éviter pour deux raisons :

La société NodeSource (nodesource.com/) maintient des binaires ainsi que des dépôts pour différentes distributions Linux.
L’installation d’une version à jour Node sous Debian, Ubuntu et consors devient aussi simple que les deux commandes suivantes :

D’autres informations et architectures sont détaillées sur le dépôt GitHub des distributions NodeSource : github.com/nodesource/distributions.

macOS ne dispose pas de gestionnaire de paquet par défaut. Quelques projets populaires permettent toutefois d’y remédier :

Si vous n’utilisez aucun de ces gestionnaires de paquet, vous pouvez essayez :

Le moyen le plus simple d’installer Node sous Windows est de télécharger l’installeur officiel depuis la page de téléchargements de Node.

Toutefois si vous utilisez déjà un gestionnaire de paquet, voici quelques recommandations :

Un raccourci pour lancer un terminal préparé pour Node et les commandes npm sera mis à disposition dans le menu Windows (voir capture ci-contre).

Node a effectué des changements dans son architecture dans sa version 0.8. Ces changements ont permis d’éviter la compilation systématique sur des architectures processeur autre que l’Intel x86.

Des binaires et installeurs sont de ce fait disponibles pour Raspberry Pi, à base de processeur ARM, entre autre.

Des binaires et instructions sont disponibles sur le site officiel de Node, pour ARMv6, ARMv7 et ARMv8 : nodejs.org/en/download/.

Un paquet deb est également proposé pour les utilisateurs du système d’exploitation Raspbian. Les instructions sont identiques à celles décrites dans la section précédente relative à la famille Debian et Ubuntu.

Chaque élément d’une chaîne de caractère est encodé au format UTF-16 et peut donc contenir 16 bits de données.

L’opérateur typeof permet d’identifier une chaîne :

On peut connaître la longueur d’une chaîne via son attribut length.

On peut nettoyer les espaces englobant une chaîne avec la méthode trim :

On peut connaître la position d’un ou plusieurs caractères via la méthode indexOf :

On peut collecter les occurrences correspondantes à un masque de caractères via la méthode match :

On peut remplacer les occurrences correspondantes à un masque de caractères via la méthode replace :

Les template literals servent à composer des chaînes de caractère multilignes et/ou contenant des expressions ECMAScript :

Les template literals peuvent se préfixer d’un nom de fonction. Ce mécanisme nommé tagged template literals sert de filtre pour interpréter et interpoler le contenu de chaque template (élément contenu dans ${}). Vous pouvez écrire vos propres fonctions mais aussi utiliser des modules npm.
L’exemple suivant illustre une sécurisation de contenu tiers à l’aide de la fonction safeHtml fournie par le module common-tags (npmjs.com/common-tags) :

Tous les nombres en ECMAScript sont des flottants (double précision) respectant le standard IEEE 754. Un nombre peut donc contenir 64 bits de données, comme en Python et PHP, entre autres.

L’opérateur typeof permet d’identifier un nombre :

On peut effectuer des opérations mathématiques grâce aux opérateurs + (addition), - (soustraction), * (multiplication), / (division) et % (modulo).

L’exception dont il faut se méfier est l’addition, car le signe + est également l’opérateur de concaténation de chaîne.
Dès qu’une chaîne est détectée, l’opération d’addition est remplacée par une concaténation.

Les fonctions parseInt et parseFloat permettent de respectivement de convertir en nombre entier et nombre flottant :

La méthode isNaN permet d’être sûr de ne pas manipuler un nombre indésirable :

Il également possible de choisir le nombre de décimales après la virgule avec la méthode toFixed.
Attention toutefois, la valeur retournée est de type String :

L’opérateur typeof ne permet pas d’identifier une date. Il convient d’utiliser instanceof :

Il également possible d’obtenir la date actuelle exprimée en millisecondes avec Date.now :

L’opérateur typeof ne permet pas d’identifier un tableau. Il faut pour cela privilégier la méthode isArray :

Il est possible de connaître la longueur d’un tableau en utilisant la propriété length :

La méthode join permet de concaténer tous les éléments d’un tableau avec le séparateur de votre choix :

À l’inverse, la méthode from prend en charge la création de tableau à partir d'itérables ou de structures similaires à des tableaux, comme arguments ou NodeList (dans un navigateur).

En complément, la méthode concat permet de concaténer d’autres éléments :

La fonction de tri via la méthode sort se base sur des comparaisons positives, négatives ou neutres pour retourner un nouveau tableau, réindexé :

Les méthodes suivantes sont des nouveautés d’ECMAScript 5. Elles facilitent énormément les itérations sur les tableaux tout en ajoutant une orientation fonctionnelle, utile pour la lisibilité du code.

La méthode map permet de retourner un nouveau tableau avec des valeurs modifiées :

La méthode filter quant à elle retourne un nouveau tableau ne contenant que les éléments retournant une valeur positive :

De manière similaire, les méthodes some et every retournent un booléen si au moins une itération et toutes les itérations ont renvoyé une valeur positive :

ECMAScript 2015 introduit les méthodes find et findIndex, respectivement pour retourner une valeur et son index selon une fonction prédicat :

La méthode reduce a un comportement similaire à sort mais fonctionne de manière accumulative :

Dans ECMAScript, tout est objet. C’est le prototype qui détermine le comportement dudit objet. Les objets peuvent être créés de manière littérale, avec la fonction Object.create ou via un constructeur.
À la différence d’un Array, il est possible de nommer une clé par une chaîne de caractère – statique ou dynamique – ou avec un symbole.

L’opérateur typeof permet d’identifier la primitive d’une variable — au sens d’ECMAScript, pas au sens logique de votre application, c’est à dire le prototype d’un objet.

L’opérateur instanceof ou la méthode getPrototypeOf permettent justement de comparer les appartenances logiques.

Object.keys extrait les propriétés énumérables d’un objet, à la différence de Object.getOwnPropertyNames() :

Object.defineProperty permet de régler finement d’autres spécificités d’un objet, dont des accesseurs (getters) et des mutateurs (setters). Ces attributs spéciaux nous autorisent la création de propriétés calculées, de propriétés en lecture seule ou de maitriser l’écriture d’une propriété :

Trois choses sont à souligner dans cet exemple.

Tout d’abord, notre définition de mutateur ajoute de la sécurité. Sa valeur est garantie et nous savons que book.date_published sera systématiquement une date.

Inconvénient, nous n’avons d’autre choix que de stocker la date dans une autre propriété, ici book._published_at. Et rien ne nous empêche de la modifier directement et d’invalider une partie de notre raisonnement…
Il nous faudrait trouver un moyen de stocker la valeur du _mutateur_ et de l'accesseur de manière privée.

Enfin, les propriétés sont assignées uniquement à l’objet book. Si nous voulions les généraliser à plusieurs instances d’objets se ressemblant, nous les définirions alors dans une classe.

Nous pouvons définir des accesseurs et des mutateurs avec une notation raccourcie, ayant exactement le même effet. Reprenons l’exemple précédent :

Object.assign étend des structures existantes et la définition de valeurs par défaut. Les clés et valeurs sont copiées de gauche à droite avant d’être assignées dans le premier paramètre :

L’affectation par décomposition (destructuring) est une manière élégante et intuitive de piocher dans un tableau ou dans un objet. La décomposition n’altère pas le contenu des variables destructurées.

Les valeurs d’un tableau sont décomposées dans l’ordre tandis que l’opérateur spread (…​) permet d’assigner le reste des valeurs dans une seule et même variable ou constante :

Il est également possible de sauter des valeurs en ne nommant pas autant de variables ou de constantes lors de la décomposition :

Le même mécanisme existe pour les objets, y compris dans des arguments de fonction :

Comme indiqué en début de section, il est possible de nommer les clés de manière dynamique mais aussi d’utiliser une syntaxe raccourcie d’assignation de valeur :

Les fonctions permettent d’isoler des portions de code et de les rendre réutilisables via l’utilisation de paramètres.

Vous pouvez les déclarer via une expression ou une déclaration assignée à une variable. La déclaration d’une fonction est soumise à la portée du contexte dans lequel le bloc de code est placé. Une fonction peut être nommée (function nomDeLaFonction(){ …​ }), anonyme (function (){ …​ }) ou dite fléchée (() ⇒ { …​ }).

Les fonctions anonymes sont fréquemment employées en tant que callbacks ou dans des contextes itératifs (tels Array.map etc.)

Il est important de noter que la déclaration d’une fonction et son exécution sont deux choses différentes.

Le code contenu dans le bloc déclaratif d’une fonction crée une portée (ou scope) qui est invisible au contexte parent de l’exécution de cette fonction. Il s’agit d’une excellente manière d’isoler des variables, notamment pour éviter des effets de bord indésirables liés à l’état d’exécution de vos scripts.

L’exemple précédent illustre un tel cas de portée en contenant la constante values dans l'IIFE : le contexte parent n’a aucune connaissance de son existence — et c’est tant mieux.

Une syntaxe abrégée est disponible via les fonctions fléchées :

Il est possible de composer des fonctions à partir d’autres fonctions en utilisant la méthode bind. Ce pattern est extrêmement puissante car il permet de modifier le contexte d’exécution de ladite fonction.

bind est également capable de créer une nouvelle fonction à laquelle vous auriez appliqué partiellement des arguments :

Ce procédé est particulièrement utile pour rendre des fonctions génériques et composer des dérivées, notamment dans le cas de pagination.

Les méthodes call et apply reposent sur le même principe mais à la différence de bind, elles exécutent immédiatement la fonction. Le seul élément différenciant correspond à la syntaxe d’application des arguments :

Les paramètres du reste (rest parameters) utilisent une syntaxe identique à la décomposition mais opèrent au niveau des arguments de fonctions :

En bref, ils sont l’équivalent de l’ancienne variable magique arguments mais avec une meilleure finesse quant aux paramètres concernés. Les éléments retournée par les paramètres du reste interface ont aussi l’avantage d’être un véritable objet de tableau – arguments est itérable mais n’est pas un tableau, et donc ne bénéficie pas des méthodes de compréhension telles que forEach, map, etc.

Deux nouvelles interfaces d’itération sont disponibles depuis ECMAScript 2015 : Map et Set. Elles font penser respectivement à Object et Array mais diffèrent de ces primitives sur les points suivants :

Map offre quelques avantages à l’utilisation d’un Object :

Toutefois Map et Set ont quelques inconvénients :

À vous de choisir entre Object et Map ou entre Array et Set en fonction de la rigueur de vos besoins.

ECMAScript 2015 ajoute au langage des sucres syntaxiques facilitant la création et maintenance d’objets métier. Nous bénéficions d’une véritable notion de constructeur, de méthodes statiques et même d’extension de prototype — on pourrait parler d’héritage mais nous n’avons pas envie d’aller dans cette direction, pas vrai ?

Tout ce que nous attachions auparavant à une fonction, nous nous référons désormais à une classe à proprement parler.
En voici un exemple de définition :

La définition de la classe View comporte trois fonctions :

L’exemple suivant illustre le comportement de la classe View :

Nous l’avons vu précédemment au niveau des objets, ECMAScript permet de définir des accesseurs.
L’exemple suivant illustre leur définition au sein d’une classe :

La logique des accesseurs est ainsi partagée entre tous les objets étant des instances de Book.

L’exemple suivant illustre deux classes héritant de notre classe View :

HTMLView surcharge le constructeur tandis que TextView se contente du comportement par défaut défini par le constructeur de View.

L’appel à la fonction super revient à appeler le constructeur de la classe que l’on étend. Ne pas l’appeler revient à ne pas exécuter le constructeur de la classe parent.

S’il est désormais plus sûr d’utiliser l’extension de chaîne prototypale, il ne faut pas abandonner la composition pour autant.

Il est en effet bien plus simple de réutiliser (et de tester) des fonctions agnostiques de contexte — agnostiques du this — que de maintenir de grosses classes héritant sur plusieurs niveaux.

L’organisation du code autour des callbacks est difficile et ce, que ce soit en terme de maintenance, de gestion des erreurs ou de propagation d’information.

Un motif a émergé en réponse à cette complexité grandissante : les promesses. Il s’agit d’une primitive à maitriser et disponible nativement à la fois dans Node et les navigateurs modernes.

Historiquement, de nombreuses bibliothèques ont proposé leur propre implémentation de promesses mais avec le défaut de ne pas être interopérables entre elles. La spécification Promise/A+ a émergé pour établir un standard de compatibilité. ECMAScript 2015 introduit nativement cette API, la rendant alors disponible pour le web et pour Node, avec ou sans polyfill.

Les cas d’utilisation des promesses sont multiples :

La création d’une Promise consiste à appeler un constructeur. Le constructeur implémente le pattern Executor. Le constructeur transmet les fonctions d’exécution permettant de résoudre la promesse, positivement en appelant resolve ou négativement, en appelant reject.
resolve et reject transmettent les valeurs passées en argument à vos callbacks souscrivant respectivement à then et catch.

L’exemple suivant illustre une encapsulation de la fonction fs.readFile de Node en tant que promesse :

Une instance de Promise expose plusieurs méthodes pour propager le statut de son exécution. Les plus courramment employées sont then et catch:

Illustrons désormais la consommation d’une promesse en se basant sur le code précédent :

Promise.all est une méthode statique de l’API Promise qui retourne elle-mêm une promesse. Elle sera résolue positivement lorsque toutes les promesses passées en argument seront résolues ou négativement dès que l’une d’entre elles échoue.

Reprenons le précédent exemple pour compter en parallèle les dépendences de trois fichiers package.json :

Usez et abusez des promesses : elles sont un des meilleurs moyens à notre disposition pour modulariser, linéariser et clarifier le sens du flot de notre code.

Nous aborderons à nouveau les promesses en tant que design pattern dans le chapitre 3.

Nous avons beaucoup appris sur les différents moyens d’organiser notre code de manière asynchrone. Peut-être avec une indigestion de then().
Les opérateurs async et await sont là pour respectivement :

Une promesse placée derrière un await jettera une exception. Cette exception est interceptable avec un bloc try/catch, comme du code synchrone.

Reprenons une nouvelle fois notre exemple précédent, en combinant la transformation en promesses et les opérateurs async et await :

À travers cet exemple on comprend qu’une fonction async retourne en réalité une promesse. Promesse résolue lorsque toutes ses conditions await sont elles aussi résolues séquentiellement.

L’inconvénient de notre exemple est que la lecture des fichiers ne se fait plus en parallèle mais bel et bien de manière séquentielle. En effet, notre code est mis en pause à chaque itération de boucle, lors de l’appel de readFilePromise.

Les expressions régulières en JavaScript permettent de pratiquer des recherches de motifs simples et complexes au sein de chaînes de caractères. Elles sont inspirées de l’implémentation dans Perl 5.

L’opérateur instanceof permet d’identifier une instance d’expression régulière :

La méthode exec permet de capturer les occurrences d’une expression régulières au sein d’une chaîne de caractères :

Plusieurs drapeaux peuvent être utilisés :

À la manière de exec, la méthode test se contente de renvoyer un booléen si un motif a été trouvé ou non :

L’introduction du support natif du parsing JSON dans ECMAScript 5 a apporté un grand confort dans la consommation de données issues d’API. La sécurité de cette consommation a été améliorée de par sa prise en charge par les développeurs de VM ECMAScript.

La fonction JSON.parse tente de convertir une chaîne de texte supposée au format JSON en un objet natif :

À l’inverse, la fonction JSON.stringify convertit un objet natif en chaîne de caractère au format JSON :

Toute personne ayant développé du JavaScript pour le navigateur a très certainement utilisé console.log pour tracer l’état d’une expression lors de l’exécution de son code.

Trois fonctions sont à garder dans un coin de la tête :

console.log affiche une représentation textuelle d’une expression et la formate avec des motifs équivalents à la fonction C printf().
Ce contenu est envoyé vers la sortie standard, process.stdout :

console.error a exactement le même comportement mais redirige vers le flux d’erreur, process.stderr.

console.trace envoie l’état de la stack trace vers le flux d’erreur :

Pour en savoir plus sur les méthodes et fonctions disponibles, reportez-vous à la documentation en ligne du module console sur nodejs.org/api/console.html.

L’objet process correspond à l’instance de l’environnement Node en cours d’exécution.

Il permet de s’interfacer avec le système, en écoutant les évènements qu’il envoie au processus ou en écoutant les évènements que Node s’apprête à envoyer au système d’exploitation.

Le tableau process.argv contient le chemin du script exécuté ainsi que les différents arguments transmis à Node :

Exécutons ce même script avec différents arguments :

Il n’en faut pas davantage pour bâtir votre premier programme en ligne de commande. Pour des besoins plus avancés, il existe un certain nombre de modules npm pour exploiter les options et arguments.

Le deuxième ensemble d’objets à connaître est le trio process.stdin, process.stdout et process.stderr. Ce sont trois flux (Streams) qui permettent d’accéder respectivement à l’entrée standard, à la sortie standard et à l’erreur standard.

Si ces noms ne vous parlent peut-être pas, c’est parce qu’ils sont directement inspirés d’UNIX. Ils sont directement accessibles via l’interface JavaScript de Node.

Le script suivant convertit toute chaine de caractère envoyée vers l’entrée standard en lettres majuscules :

Exécutons ce script sur un système Unix :

Le concept de Streams sera développé petit à petit au fil de ce chapitre et dans le reste du livre. C’est un concept puissant mais il y a des fonctionnalités plus simples à appréhender pour débuter.

Nous venons de voir que process est un objet contenant plusieurs attributes précieux. L’héritage prototypal est utilisé pour le rendre capable d’émettre des évènements via la méthode process.on(). Cette méthode est utilisée pour écouter les évènements système et permettre à nos programmes de réagir convenablement.

L’exemple suivant illustre la réaction face à un signal d’interruption (abrégé en SIGINT, pour Signal Interrupt). Ce signal est notamment émis en pressant les touches CTRL et C.

Et maintenant son exécution dans un terminal Unix :

process.title est une API intéressante pour assigner un titre de process. Cela concerne notamment les commandes de liste de processus actifs (comme ls). On pourrait penser que cela offre l’avantage de rendre un processus singuler et donc plus facile à repérer :

Le résultat lorsqu’on liste les processus :

Attention toutefois car il se trouve que le résultat de ce nommage peut se révéler imprédictible en fonction des systèmes d’exploitation où le programme est exécuté.

Il est recommandé de ne pas utiliser process.title et s’il y a besoin d’identifier un processus, de passer par d’autres mécanismes de gestion de processus. Nous aborderons ce sujet au chapitre 7 Héberger, déployer et monitorer.

Pour en savoir plus sur les méthodes et fonctions disponibles, reportez-vous à la documentation en ligne du module process sur nodejs.org/api/process.html.

Les modules CommonJS sont au cœur du fonctionnement de Node. Ils permettent d’isoler, d’empaqueter et de rendre le code réutilisable.

La magie opère principalement grâce à la fonction require et à l’objet module. Ils s’occupent respectivement de charger et de déclarer un module.

Techniquement parlant, un module est un fichier JavaScript dont toutes les variables sont privées et inaccessibles depuis l’extérieur. Seules les variables exposées par module.exports sont publiquement accessibles.

Prenons l’exemple suivant :

Dans le précédent exemple, le module currency-format.js est exposé tant que fonction. Les variables currencies et formatNumber restent encapsulées dans la portée du module.

Admettons que nous souhaitons utiliser ce module dans un programme, ici currency-main.js :

La fonction require chargera le fichier currency-format.js et assignera le résultat de l’export dans la variable de votre choix, ici, setupFormatter.

Lors de l’exécution du précédent programme, nous avons confirmation que la variable currencies contenue dans le module currency-format.js n’est pas disponible dans le module currency-main.js.

Pour en savoir plus sur les méthodes et fonctions disponibles, reportez-vous à la documentation en ligne des modules sur nodejs.org/api/modules.html.

Nous avons abordé le mécanisme de chargement de modules dans le point précédent. Regardons plus en détails le comportement de la fonction require.

La fonction require permet de charger des fichiers locaux, des modules JavaScript, des modules binaires ou même des fichiers JSON :

require est une fonction synchrone et bloquante. Cela permet de garantir l’ordre de chargement des modules.

Qui dit bloquant dit que si du code exécuté dans le module avant l’export ralentira l’exécution tant que le module n’aura pas été mis en cache.
L’exemple suivant illustre le phénomène :

Dans l’exemple précédent, il faut attendre que la boucle soit complétée avant que la fonction require ne rende la main et procède à l’exécution des instructions suivantes :

Il faut s’assurer que le code exécuté pendant le chargement d’un module soit exclusivement non bloquant pour conserver la performance applicative.
Le concept d’asynchronicité et de non bloquant est explicité plus en détail dans Comprendre les accès non-bloquants.

Node optimise le chargement des modules en les mettant en cache. Autrement dit et de manière générale, un module est chargé une seule fois. L’unicité d’un module est assurée par son emplacement au sein du système de fichiers, en se basant sur la propriété module.id.

Prenons le cas de ce module :

Le précédent module affichera son identifiant unique à chaque fois qu’il est chargé. Dès que la méthode run() de l’objet exporté sera appelée, elle incrémentera la variable privée counter et retournera sa nouvelle valeur.

Le module suivant fait deux fois appel à increment-module.js et assigne le résultat dans deux variables différentes. Ceci dans le but de vérifier le comportement du mécanisme de chargement des modules Node.

Il ne reste plus qu’à l’exécuter pour constater ce qu’il se passe :

Le module ayant déjà été chargé une fois, Node n’ira pas charger le fichier une deuxième fois et ne créera pas de nouvelle instance de l’objet module. Il se contente de retourner la même instance de module.

Ce comportement peut être exploité en tant que design pattern Singleton, explicité plus en détail dans ce même chapitre.

Enfin, Node lancera une exception si une erreur se produit lors du chargement (fichier inexistant, erreur de syntaxe dans le fichier à charger).

Pour en savoir plus sur le fonctionnement de la fonction require, reportez-vous à la documentation en ligne des modules sur nodejs.org/api/modules.html.

__filename et __dirname sont des constantes indiquant respectivement le chemin absolu du fichier exécuté et le chemin absolu du répertoire contenant le fichier exécuté.

Utiliser __filename et __dirname est utile pour travailler avec des chemins absolus, indépendamment du répertoire de travail de Node.

Pour des raisons de commodité, Node fournit des implémentations de setTimeout, de setInterval et de setImmediate. Pour rappel, ces fonctions de temps ne font pas partie de JavaScript mais de la spécification DOM Level 0.

Ces fonctions exécutent une fonction respectivement une seule fois dans un délai imparti, un nombre de fois indéterminé à un intervalle imparti et une seule fois immédiatement :

Pour en savoir plus sur les méthodes et fonctions disponibles, reportez-vous à la documentation en ligne du module timers sur nodejs.org/api/timers.html.

La variable globale est un cas spécial. Elle n’est prédéfinie que dans le terminal interactif (_REPL).

Cette variable magique contient systématiquement le résultat de la dernière évaluation de code.